# 给定缓存
def cache_deco(func):
    cache = {0: 0, 1: 1, 2: 1, 6: 8, 8: 21, 16: 987, 27: 196418}
    def wrapper(*args, **kwargs):
        values = cache.get(args[0])
        if values == None: # 缓存中无数值
            result = func(*args, **kwargs)  #进行递归
            return result
        else:
            print('【缓存】本次通过缓存读取斐波那契的第{}个数字'.format(args[0]))
            return values   # 缓存中有值，跳过递归，直接返回数值
    return wrapper


@cache_deco
def fibo2(n):
    print('【递归】本次通过递归计算斐波那契的第{}个数字'.format(n))
    if n < 2:
        return n
    return fibo2(n-1) + fibo2(n-2)


fibo2(30)
'''
通过读取固定缓存的方式，仍会进行大量的递归，速度较慢
'''


# 计算时自动保存缓存
def cache_deco_auto(func):
    cache = {}
    def wrapper(*args, **kwargs):
        if args not in cache:      # 缓存中无数值
            cache[args] = func(*args, **kwargs)     #计算并增加缓存，打印后可以看到是先增加的{1：1}，然后是{0：0}、{2：1}
            print('在计算第{}个数字时增加了缓存{}'.format(args[0],{args[0]:cache[args]}))
            return cache[args]
        else:
            return cache[args]   # 缓存中有值，跳过递归，直接返回数值
    return wrapper

@cache_deco_auto
def fibo(n):
    print('【递归】本次通过递归计算斐波那契的第{}个数字'.format(n))
    if n < 2:
        return n
    return fibo(n-1) + fibo(n-2)


fibo(100)
'''
通过自动建立缓存的方式，速度很快
'''


# 迭代器与生成器
dict1 = {'迭代器': '一个未知长度的数据流，用next获取下一个指令', '生成器': '一个特殊的迭代器，提供了惰性延迟的功能，强调指令上的执行[yield]'}
print(dict1.keys())
print(dict1.values())
print(dict1.items())